import jdk.swing.interop.SwingInterOpUtils;

public class text {
    //字符串与整型之间的转换
    public static void main14(String[] args) {
        //int 转成 String
        int num = 10;
               // ⽅法1
        String str1 = num + "";
               // ⽅法2
        String str2 = String.valueOf(num);

        //String 转成 int
        String str = "100";
        int num = Integer.parseInt(str);
    }

    //输出的拼接
    public static void main13(String[] args) {
        String s1 = "hello";
        String s2 = " world";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1+s2); // s1+s2表⽰：将s1和s2进⾏拼接

        int a = 10;
        System.out.println("a = " + a);
        int b = 20;
        System.out.println("b = " + b);

        System.out.println("a + b = " + (a + b));//a + b =30.
        System.out.println(a+b+"a+b=");//30a+b=                  先运算后拼接
        System.out.println("a + b = " + a + b);//a + b = 1020     先拼接故后面也是拼接
    }

    //类型提升,不同类型的数据之间相互运算时，数据类型⼩的会被提升到数据类型⼤的。
    public static void main12(String[] args) {
        //int与long之间：int会被提升为long
        int a = 10;
        long b = 20;
        //int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
        long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long

        //byte与byte的运算
        byte a = 10;
        byte b = 20;
        byte c = a + b; //编译错误    会先提升为4字节在运算
        System.out.println(c);
        byte d = (byte) (a+b);//强制转换  正确编译
        //计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 诸如 byte 和short 这种低于 4 字节的, 会先提升成 int, 再参与计算
    }

    //强制类型转换(不能⾃动完成。数据范围⼤的到数据范围⼩的。)可能精度丢失
    public static void main11(String[] args) {
        int a = 10;
        long b = 100L;
        b = a;                // int-->long，数据范围由⼩到⼤，隐式转换
        a = (int)b;           // long-->int, 数据范围由⼤到⼩，需要强转，否则编译失败
        float f = 3.14F;
        double d = 5.12;
        d = f;                // float-->double，数据范围由⼩到⼤，隐式转换
        f = (float)d;         // double-->float, 数据范围由⼤到⼩，需要强转，否则编译失败
        byte b1 = 100;        // 100默认为int，没有超过byte范围，隐式转换
        byte b2 = (byte)257;  // 257默认为int，超过byte范围，需要显⽰转换，否则报错
    }

    //⾃动类型转换(编译器会⾃动进⾏处理,数据范围⼩的转为数据范围⼤的)
    public static void main10(String[] args) {
        System.out.println(1024); // 整型默认情况下是int
        System.out.println(3.14); // 浮点型默认情况下是double
        int a = 100;
        long b = 10L;
        b = a; //int 类型的值 ⾃动转换为了long类型
        float f = 3.14F;
        double d = 5.12;
        d = f; //float 类型的值 ⾃动转换为了double 类型
    }

    // 布尔类型，java未规定布尔类型的大小
    public static void main9(String[] args) {
        boolean b = true;
        System.out.println(b);
        b = false;
        System.out.println(b);
        //boolean 类型的变量只有两种取值, true 表⽰真, false 表⽰假.
        //Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表⽰ true, 0 表⽰ false 这样的⽤法.

        //System.out.println(Boolean.MAX_VALUE);
        //System.out.println(Boolean.MIN_VALUE);
        //boolean的包装类型为Boolean。
    }

    //字符型，2字节
    public static void main8(String[] args) {
        char c1 = 'A'; // ⼤写字⺟
        char c2 = '1'; // 数字字符
        System.out.println(c1);
        System.out.println(c2);
        // 注意：java中的字符可以存放整型
        //1.  单引号 + 单个字⺟
        char c3 = '帅';
        System.out.println(c3);
        //2. 计算机中的字符本质上是⼀个整数. 在 C 语⾔中使⽤ ASCII 表⽰字符, ⽽ Java 中使⽤ Unicode 表⽰
        //字符. 因此⼀个字符占⽤两个字节, 表⽰的字符种类更多, 包括中⽂.
        char c4 = 97;
        System.out.println(c4);//a
        //unicode字符对照表
        System.out.println(Character.MAX_VALUE);
        System.out.println(Character.MIN_VALUE);
        //3. char的包装类型为Character
    }

    //单精度浮点型，4字节
    public static void main7(String[] args) {
        float num = 1.0f; // 要加f或F（不然默认为双精度浮点型）
        System.out.println(num);
        System.out.println(Float.MAX_VALUE);
        System.out.println(Float.MIN_VALUE);
    }

    //双精度浮点型,8字节
    public static void main6(String[] args) {
        double d = 12.5;
        System.out.println(d);
        System.out.println(Double.MAX_VALUE);
        System.out.println(Double.MIN_VALUE);

        int a = 1;
        int b = 2;
        System.out.println(a/b);//结果为0（向下取整）
        double c = 1.0;
        double e = 2.0;
        System.out.println(c/e);//结果为0.5

        double num = 1.1;
        System.out.println(num * num); // 输出1.2100000000000002
        /*double 类型的内存布局遵守 IEEE 754 标准(和C语⾔⼀样), 尝试使⽤有限的内存空间表⽰可能⽆限的⼩数,
        势必会存在⼀定的精度误差，因此浮点数是个近似值，并不是精确值。*/
    }
    //byte,short,int,long都可以定义整型变量

    //字节类型 1字节
    public static void main5(String[] args) {
        byte a = 10;
        System.out.println(a);
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);
    }

    //短整型 2字节
    public static void main4(String[] args) {
        short a = 10;
        System.out.println(a);
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);
    }

    //长整型long，8字节
    public static void main3(String[] args) {
        long d = 10L;
        System.out.println(d);
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);
    }

    //整型int，4字节
    public static void main2(String[] args) {
        int a = 10;
        System.out.println(a);
        //int类型变量所能表示的范围（Integer是int的包装类型）
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }


    //main
    public static void main1(String[] args) {
        //sout
        System.out.println("hello");//字符串常量
        System.out.println(100);//整型
        System.out.println(3.14);//浮点数
        System.out.println('a');//字符
        System.out.println(true);//布尔
        System.out.println(false);
        //printf("%d",10)
        /*           数据类型       关键字       内存占用
               整数    字节         byte          1字节
                      整型 （默认）  int           4
                      短整型        short         2
                      长整型        long          8
       数据类型 浮点数   单精度浮点类型 float         4
                      双精度浮点类型 double （默认） 8
               字符                 char          2
               布尔                 boolean        无    true和false

        */
        //格式化输出
        System.out.printf("%d\n",100);

        //print+ln换行，不加ln不换行
        System.out.print(3.14);
        System.out.println("==========");
    }
}
